import org.junit.jupiter.api.Test;

import java.math.BigDecimal;
import java.util.*;

public class MergeAndSort {

    public static int Compare(Map<String,Object> a, Map<String,Object> b, List<String> fields) {
        final StringBuilder x=new StringBuilder("123456789");
        while(a.containsKey(x)&&b.containsKey(x)){
            x.append('0');
            if(x.length()>30){
                throw new RuntimeException("键生成失败,生成了过长的key");
            }
        }
        fields.add(x.toString());
        a.put(x.toString(),0);
        b.put(x.toString(),0);
        int i=0;
        int res=0;
        do{
            res=a.get(fields.get(i)).toString().compareTo(b.get(fields.get(i)).toString());
        }while (res==0);
        return res;
    }

    //1.两个list都是有序的,
    // 2.且分别是无重复元素
    //在指定比较器上相同时,把第二个挂载到第一个上
    public static <T> void merge(Comparator<? super T> comparator, List<T> res, List<T> res2){
        int i=0;
        int j=0;
        //1.必须假定res2中存在某个元素大于任意res的元素
        //假设一个不可能的数据,这个数据大于任意res的元素
        T sentinel = null;//这个假如是最大数据
        res2.add(sentinel);
        while(i<res.size()){
            T item = res.get(i);
            T item2 = res2.get(j);
            int cres = comparator.compare(item, item2);
            if (cres > 0) {
                j++;
            } else if (cres < 0) {
                i++;
            } else {
                //todo put your merge codes here
                i++;
                j++;
            }
        }
        //2.或者当res2中没有元素大于任意res的元素时,把res的剩下元素加入到最终列表中
        while(i<res.size()){
//            if (i == first_map.size()) //second_map,自身不存在重复数据,所以rxd的最后一个数据不会与second_map第一个数据相同.否则添加后,rdx中会有重复数据.
//                rxd.addAll(second_map.subList(j, second_map.size()));
            T item = res.get(i);
            T item2 = res2.get(j);
            int cres = comparator.compare(item, item2);
            if (cres > 0) {
                j++;
            } else if (cres < 0) {
                i++;
            } else {
                //todo put your merge codes here
                i++;
                j++;
            }
        }
    }
    //把第二个挂载到第一个上
    public static void DXD(){
        HashMap<String, Object> sentinel = new HashMap<>();
        List<Map<String, Object>> res2=null;
        List<Map<String, Object>> res=null;
        //假设一个不可能的数据
        sentinel.put("bd_id", Long.MAX_VALUE);
        sentinel.put("di_id", Long.MAX_VALUE);
        res2.add(sentinel);
        int i=0;
        int j=0;
        final String[] fields=new String[]{"bd_id","di_id"};
        while(i<res.size()){
            Map<String, Object> item = res.get(i);
            Map<String, Object> item2 = res2.get(j);
            int cres = Compare( item, item2, Arrays.stream(fields).toList());
            if (cres > 0) {
                j++;
            } else if (cres < 0) {
                i++;
            } else {
                //todo put your merge codes here
            }
        }
    }

    //todo 单独合并每个列表的重复项;然后归并两个列表

    private final class DD extends HashMap<String,String>{
    }
    @Test
    public void test1(){
        merge((a,b)->{
            String s = a.get(0);
            return 1;
        },new ArrayList<DD>(),new ArrayList<DD>());
    }

    //参数约束
    private final class DA<U,T extends DA<U,T>>{
        private T next;
        private U m;
    }

    //节点类
    private final class DA2{
        private Map<String,DA2> child;
        private String key;
    }

    //todo 依附与合并

    //主列表,次列表
    //1.主次列表是同等的
    //2.次列表依附主列表,或者说,次列表是主列表的一个属性
}
